home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 5 / The 640 Meg Shareware Studio CD-ROM Volume V (Data Express)(1994).ISO / amiga / tempdemo.lha / ProgrammersInfo / InternodeLiveChat.mod.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-22  |  14.1 KB  |  571 lines
  1. /*
  2.  
  3.      .----------------------------------------------------------------.
  4.      | NODE | LOGON | HANDLE                    | ACTiViTY            |
  5.      |======|=======|===========================|=====================|
  6.      |   1  | 17:45 | The Skeleton              | Chat System         |
  7.      |------|-------|---------------------------|---------------------|
  8.      |   2  | --:-- | Awaiting a call           | Idle                |
  9.      |------|-------|---------------------------|---------------------|
  10.      |   3  | --:-- | Awaiting a call           | Idle                |
  11.      `----------------------------------------------------------------'
  12.  
  13. Press <CTRL-?> to see menu.
  14.  
  15.  
  16. <CTRL-S> Send Invite for Chat
  17. <CTRL-W> Who's Online
  18. <CTRL-X> Exit Chat
  19.  
  20.  
  21. */
  22. //**********************
  23. //*****  Includes  *****
  24. //**********************
  25.  
  26. #include <proto/all.h>
  27. #include <stdio.h>
  28.  
  29. #include <string.h>
  30. #include <tempest/headers.h>
  31.  
  32. //********************************
  33. //*****  Structures/Defines  *****
  34. //********************************
  35.  
  36. struct MyMessage
  37.  {
  38.   struct Message Msg;
  39.   struct User User;
  40.   char text[255],
  41.        text1[255];
  42.   int car,Value,Data;
  43.   long LongValue;
  44.   int  IntValue;
  45.  };
  46.  
  47. struct User User;
  48. struct MsgPort *MyPort = NULL;
  49. struct MyMessage *msg;
  50. struct node_info nody[15];
  51.  
  52. #define DROP if(EXIT_FLAG) CloseStuff();
  53.  
  54. void CloseStuff();
  55. int  DOORIO();
  56. void input(char mstring[],int len);
  57. void WriteFile(char ostring[],char mstring[]);
  58. void Send(int);
  59. void ListNodes(void);
  60. int Loadnody(int);
  61. int CheckKey(void);
  62. void msgs(char *);
  63. void CheckMsg(void);
  64.  
  65. //******************************
  66. //*****  Global Variables  *****
  67. //******************************
  68.  
  69. int  NODE,NODES,OTHERNODE=0;
  70. int  EXIT_FLAG, DOOR_DATA, DOOR_CAR, DOOR_VALUE, DOOR_VALUE1 = 0,
  71.      Error,first = 0;
  72. char MyName[255],st[100],DOOR_MSG[255],DOOR_MSG1[255],nodename[255];
  73.  
  74. //*****************************
  75. //*****  PL (Print Line)  *****
  76. //*****************************
  77.  
  78. void pl(fmt,a1,a2,a3,a4)
  79. char *fmt;
  80.  {
  81.   char s[255];
  82.   sprintf(s,fmt,a1,a2,a3,a4);
  83.   DOOR_DATA=1; strcpy(DOOR_MSG,s); DOORIO();
  84.  }
  85.  
  86. //******************
  87. //*****  Main  *****
  88. //******************
  89.  
  90. void main(int argc,char *argv[])
  91. {
  92.  char string[200],string1[200];
  93.  char string2[200],string3[100]; // Word Rap Only
  94.  int line,stat,key,sending=0,receive=0,back,i;
  95.  register x,y;
  96.  
  97.  if(!DoorStart(argv[1])) { PutStr("[os2] Tempest Door\n"); exit(0); }
  98.  
  99. //*************************
  100. //*****  Load Nody's  *****
  101. //*************************
  102.  
  103.  pl("\r\nPlease Wait.. Loading Info...");
  104.  
  105.  NODE = atoi(argv[1]);
  106.  stat=Loadnody(NODE);
  107.  if(stat==0)
  108.   {
  109.    pl("NodeInfo File Not Found!\r\n");
  110.    CloseStuff();
  111.   }
  112.  NODES = nody[NODE].SystemDataInfo->NumberOfLines + 1;
  113.  strcpy(nody[NODE].chatmsgbuffer,NULL);
  114.  nody[NODE].chatbuffer[0]=NULL;
  115.  *nody[NODE].chatfromnode=0;
  116.  *nody[NODE].chatroom=0;
  117.  
  118.  y=0;
  119.  for(x=1;x<NODES+1;x++)
  120.   {
  121.    if(x!=NODE)
  122.     {
  123.      stat=Loadnody(x);
  124.      if(stat==0) setmem(&nody[x],sizeof(struct node_info),NULL);
  125.      if(*nody[x].AN==32) y++;
  126.     }                           // List chat rooms
  127.   }
  128.  
  129.   // Ask and join which chat room.
  130.  
  131.  if(y>=2)
  132.   {
  133.    pl("\r\n\r\nSorry, there is already 2 users in live chat system!\r\n\r\n");
  134.    CloseStuff();
  135.   }
  136.  pl("\f[Live Chat Module v0.4]   By Michael Bockert [01-12-94]\r\n");
  137.  pl("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
  138.  
  139. //*********************************
  140. //*****  Get Input & Send it  *****
  141. //*********************************
  142.  
  143.  strcpy(nody[NODE].activity,"Live Chat Module");
  144.  *nody[NODE].AN=32;
  145.  
  146.  ListNodes();
  147.  
  148.  sprintf(string,"\r\n\r\n%s has entered live chat!\r\n\r\n",User.Name);
  149.  msgs(string);
  150.  
  151.  REDO:
  152.  
  153.  pl("\r\n\r\n<CTRL-S> Send Invite for Chat\r\n<CTRL-W> Who's Online.\r\n<CTRL-X> Exit Chat.\r\n\r\n");
  154.  
  155.  string3[0]=NULL;
  156.  string[0]=NULL;
  157.  x=0;
  158.  line=0;
  159.  CheckMsg();
  160.  while(1)
  161.   {
  162.    REINPUT:
  163.  
  164.    if(sending==0) CheckMsg();
  165.  
  166.    //********************************
  167.    //********************************
  168.    //*****  CHECK REMOTE INPUT  *****
  169.    //********************************
  170.    //********************************
  171.    if(nody[NODE].chatbuffer[0]!=NULL)
  172.     {
  173.      if(nody[NODE].chatbuffer[0]==13) pl("\r\n");
  174.      if(receive==0)
  175.       {
  176.        pl("\r\n[%2d] %s> ",*nody[NODE].chatfromnode,nody[*nody[NODE].chatfromnode].UserInfo->Name);
  177.       }
  178.      receive=1;
  179.      sending=0;
  180.      switch(nody[NODE].chatbuffer[0])
  181.       {
  182.        case  8: pl("\b \b"); break;                    // BackSpace
  183.        case 13: break;                                 // Return Key
  184.        default: pl("%c",nody[NODE].chatbuffer[0]);
  185.       }
  186.      *nody[NODE].chatfromnode=0;
  187.      nody[NODE].chatbuffer[0]=NULL;
  188.      goto REINPUT;
  189.     }
  190.  
  191.    //**************************************
  192.    //**************************************
  193.    //*****  CHECK LOCAL USER'S INPUT  *****
  194.    //**************************************
  195.    //**************************************
  196.  
  197.    key=CheckKey();
  198.    DROP;
  199.    if(key!=0)
  200.     {
  201.      if(key==13)
  202.       {
  203.        string3[0]=NULL;
  204.        x=0;
  205.        line=0;
  206.        pl("\r\n");
  207.        CheckMsg();
  208.       }
  209.      if((sending==0)&&(key!=8))
  210.       {
  211.        pl("\r\n[%2d] %s> ",NODE,User.Name);
  212.        stat=strlen(User.Name);
  213.        x=stat+7;
  214.        line=x+1;
  215.       }
  216.      receive=0;
  217.      switch(key)
  218.       {
  219.        // BackSpace
  220.        case  8: if((x<1)&&(line==0)) goto REINPUT;
  221.                 else if(x<line)      goto REINPUT;
  222.                 pl("\b \b");
  223.                 x--;
  224.                 string3[x]=NULL;
  225.                 break;
  226.  
  227.        // Return Key
  228.        case 13: break;
  229.        case 14: goto REINPUT;
  230.  
  231.        // CTRL-X or CTRL-C = Quit Program
  232.        case  3:
  233.        case 24: pl("\r\n\r\n");
  234.                 sprintf(string,"\r\n\r\n%s has left live chat!\r\n\r\n",User.Name);
  235.                 msgs(string);
  236.                 strcpy(nody[NODE].activity,"Idle");
  237.                 *nody[NODE].AN=30;
  238.                 CloseStuff();
  239.  
  240.        // CTRL-W = List Nodes
  241.        case 23: ListNodes();
  242.                 sending=0;
  243.                 goto REDO;
  244.  
  245.        // CTRL-S = Send Invite
  246.        case 19: ListNodes();
  247.                 pl("\r\n\r\nInput Node Number to invite: ");
  248.                 input(string,2);
  249.                 DROP;
  250.                 y = atoi(string);
  251.                 if(nody[y].UserInfo->Name[0]!=NULL)
  252.                  {
  253.                   if((*nody[y].AN!=58)&&(*nody[y].AN!=56)&&(*nody[y].AN!=4))
  254.                    {
  255.                     sprintf(string,"NODE:MsgToNode-%d",y);
  256.                     sprintf(string1,"\r\n%s would like to chat in InterNode Chat\r\n",User.Name);
  257.                     WriteFile(string,string1);
  258.                    }
  259.                   else pl("\r\nYou can not chat that user at this time!\r\n\r\n");
  260.                   goto REDO;
  261.                  }
  262.                 else pl("\r\nNobody on that node!\r\n\r\n");
  263.                 sending=0;
  264.                 goto REDO;
  265.  
  266.        default: pl("%c",key);
  267.       }
  268.      Send(key);
  269.      sending=1;
  270.      if(key==13) goto REINPUT;
  271.      else if(key!=8) x++;
  272.  
  273.      //**********************
  274.      //*****  WORD RAP  *****
  275.      //**********************
  276.  
  277.      string2[0]=(char)key;
  278.      string2[1]=NULL;
  279.      if(string3[0]==NULL) strcpy(string3,string2);
  280.      else                 strcat(string3,string2);
  281.  
  282.      if(x>=79)
  283.       {
  284.        strcat(string3,NULL); /// Was the problem!
  285.        back=0;
  286.        stat=strlen(string3);
  287.        for(i=stat;i>0;i--)
  288.         {
  289.          if((stat-i)>15) break;
  290.          if(string3[i-1]==' ')
  291.           {
  292.            back=stat-i;
  293.            break;
  294.           }
  295.         }
  296.        if(back==0)
  297.         {
  298.          Send(13);
  299.          string3[0]=NULL;
  300.          line=0;
  301.          x=0;
  302.          pl("\r\n");
  303.          goto REINPUT;
  304.         }
  305.        string[0]=NULL;
  306.  
  307.        y=0;
  308.        for(i=(stat-back);i<stat;i++)
  309.         {
  310.          string[y]=string3[i];
  311.          y++;
  312.         }
  313.        string[y]=NULL;
  314.        string3[0]=NULL;
  315.  
  316.        x=strlen(string);
  317.        for(i=0;i<x;i++)
  318.         {
  319.          pl("\b \b");
  320.          if(i==0) strcpy(string3,"\b \b");
  321.          else     strcat(string3,"\b \b");
  322.         }
  323.        strcat(string3,"\r\n");
  324.        strcat(string3,string);
  325.        msgs(string3);
  326.        string3[0]=NULL;
  327.        line=0;
  328.        pl("\r\n%s",string);
  329.       }
  330.     }
  331.   }
  332. }
  333.  
  334. //*****************************
  335. //*****  Find Other Node  *****
  336. //*****************************
  337.  
  338. int FindOtherNode(void)
  339. {
  340.  register int x;
  341.  int stat=0;
  342.  for(x=1;x<NODES+1;x++)
  343.   {
  344.    if((*nody[x].AN==32)&&(x!=NODE))
  345.     {
  346.      OTHERNODE=x;
  347.      stat=1;
  348.     }
  349.   }
  350.  return(stat);
  351. }
  352.  
  353. //************************************
  354. //*****  Send Text To All Nodes  *****
  355. //************************************
  356.  
  357. void Send(int key)
  358. {
  359.  register int x;
  360.  int stat=1;
  361.  if((OTHERNODE>0)&&(*nody[OTHERNODE].AN!=32)) stat=FindOtherNode();
  362.  else if(OTHERNODE==0)                        stat=FindOtherNode();
  363.  if(stat==0) return;
  364.  
  365.  nody[OTHERNODE].chatbuffer[0]=key;
  366.  *nody[OTHERNODE].chatfromnode=NODE;
  367.  for(x=0;x<300;x++)                 // Timer, not endless
  368.   {
  369.    if(*nody[OTHERNODE].chatfromnode==0) return;
  370.   }
  371. }
  372.  
  373. //****************************************
  374. //*****  Send Messages To All Nodes  *****
  375. //****************************************
  376.  
  377. void msgs(char message[])
  378. {
  379.  int stat=1;
  380.  if((OTHERNODE>0)&&(*nody[OTHERNODE].AN!=32)) stat=FindOtherNode();
  381.  else if(OTHERNODE==0)                        stat=FindOtherNode();
  382.  if(stat==0) return;
  383.  
  384.  strcpy(nody[OTHERNODE].chatmsgbuffer,message);
  385. }
  386.  
  387. //********************************
  388. //********************************
  389. //*****  CHECK FOR MESSAGES  *****
  390. //********************************
  391. //********************************
  392. void CheckMsg(void)
  393. {
  394.  if(nody[NODE].chatmsgbuffer[0]!=NULL)
  395.   {
  396.    pl(nody[NODE].chatmsgbuffer);
  397.    strcpy(nody[NODE].chatmsgbuffer,NULL);
  398.   }
  399. }
  400.  
  401. //************************
  402. //*****  List Nodes  *****
  403. //************************
  404.  
  405. void ListNodes(void)
  406. {
  407.  char string[200],string2[20];
  408.  char Handle[40],Activity[30],Time[15];
  409.  register int i;
  410.  
  411.  pl("\r\n\r\n     .----------------------------------------------------------------.\r\n");
  412.  pl("     | NODE | LoGoN | HANDLE                    | ACTiViTY            |\r\n");
  413.  
  414. //***************************
  415. //*****  Who is Online  *****
  416. //***************************
  417.  
  418.  i=1;
  419.  do
  420.   {
  421.    strcpy(Handle,nody[i].UserInfo->Name);
  422.    if((*nody[i].hide==1)&&(User.Security!=255)&&(User.Name[0]!=NULL))
  423.     {
  424.      if(nody[i].UserInfo->Slot_Number==1) Handle[0]=NULL;
  425.      else strcpy(Handle,"[ Hiding From Display ]");
  426.     }
  427.    if(Handle[0]!=NULL)
  428.     {
  429.      sprintf(string,"%s",ctime(&nody[i].UserInfo->Time_Last));
  430.      strmid(string,Time,12,5);
  431.      strcpy(Activity,nody[i].activity);
  432.      //**************************
  433.      //*****  Final Output  *****
  434.      //**************************
  435.      pl("     |------|-------|---------------------------|---------------------|\r\n");
  436. //     if(nody[i].NodeDataInfo->LocalMode==0)
  437.      sprintf(string2,"%2d",i);
  438. //     else                                   strcpy(string2," V");
  439.      pl("     |  %2s  | %5s | %-25.25s | %-19s |\r\n",
  440.          string2,Time,Handle,Activity);
  441.     }
  442.    i++;
  443.   }
  444.  while(i<NODES);
  445.  pl("     `----------------------------------------------------------------'");
  446. }
  447.  
  448. //************************
  449. //*****  Load Nody  ******
  450. //************************
  451.  
  452. int Loadnody(int node)
  453. {
  454.  char string[50];
  455.  register int y;
  456.  int file;
  457.  sprintf(string,"Node:NodeInfo_%d",node);
  458.  for(y=1;y<3;y++)
  459.   {
  460.    file=Open(string,MODE_OLDFILE);
  461.    if(file!=0)
  462.     {
  463.      Read(file,(char *)&nody[node],sizeof(struct node_info));
  464.      Close(file);
  465.      return(1);
  466.     }
  467.   }
  468.  return(0);
  469. }
  470.  
  471. //*************************
  472. //*****  Close Stuff  *****
  473. //*************************
  474.  
  475. void CloseStuff()
  476. {
  477.  DOOR_DATA=99; strcpy(DOOR_MSG,'\0'); DOORIO();
  478.  while(msg=(struct MyMessage *)GetMsg(MyPort)) ReplyMsg((struct Message *)msg);
  479.  if(MyPort) DeletePort(MyPort);
  480.  exit(0); }
  481.  
  482.  //***********************
  483.  //*****  Check Key  *****
  484.  //***********************
  485.  
  486.  // This will not wait for a key to be hit, it just simply tells me if
  487.  // there has been one hit, if so the character will be in integer form
  488.  // returned via (x) in this example
  489.  
  490.  int CheckKey(void)
  491.   { strcpy(DOOR_MSG,'\0'); DOOR_DATA=54; DOOR_VALUE1=0; DOORIO();
  492.     return(DOOR_VALUE1); }
  493.  
  494. //********************
  495. //*****  DoorIO  *****
  496. //********************
  497.  
  498. int DOORIO()
  499. {
  500.  struct MsgPort *HisPort;
  501.  struct MyMessage message;
  502.  int UPDATE;
  503.  if(EXIT_FLAG) return 0;
  504.  UPDATE=0;
  505.  HisPort = FindPort(st);
  506.  if(HisPort!=NULL)
  507.   {
  508.    message.Msg.mn_Node.ln_Type = NT_MESSAGE;
  509.    message.Msg.mn_Length = sizeof(message);
  510.    message.Msg.mn_ReplyPort = MyPort;
  511.    if(first)CopyMem(&User,&message.User,sizeof(struct User));
  512.    message.car   = 0;
  513.    message.Data  = DOOR_DATA;
  514.    message.Value = DOOR_VALUE;
  515.    message.IntValue = DOOR_VALUE1;
  516.    strcpy(message.text,DOOR_MSG);
  517.    strcpy(message.text1,DOOR_MSG1);
  518.    PutMsg((struct MsgPort *)HisPort,(struct Message *)&message);
  519.    Wait(1 << MyPort->mp_SigBit);
  520.    GetMsg(MyPort);
  521.    DOOR_DATA  = message.Data;
  522.    DOOR_VALUE = message.Value;
  523.    DOOR_VALUE1 = message.IntValue;
  524.    strcpy(DOOR_MSG,message.text);
  525.    strcpy(DOOR_MSG1,message.text1);
  526.    CopyMem(&message.User,&User,sizeof(struct User));
  527.    first=1;
  528.    UPDATE=0;
  529.    if(message.car) EXIT_FLAG=1;
  530.   }
  531.  return 0;
  532. }
  533.  
  534. //************************
  535. //*****  Door Start  *****
  536. //************************
  537.  
  538. DoorStart(char node[])
  539. {
  540.  struct MsgPort *HisPort;
  541.  EXIT_FLAG = 0;
  542.  sprintf(st,"%s:TEMPEST_DOOR",node);
  543.  HisPort = FindPort(st);
  544.  if(HisPort==NULL) return (FALSE);
  545.  sprintf(MyName,"%s:DOOR_PORT",node);
  546.  MyPort = CreatePort(MyName,0L);
  547.  if(MyPort==NULL)
  548.   {
  549.    PutStr("Cant open port");
  550.    return(int)FALSE;
  551.   }
  552.  DOORIO();
  553.  return (int)TRUE;
  554. }
  555.  
  556. //*******************
  557. //*****  Input  *****
  558. //*******************
  559.  
  560. void input(char mstring[],int len)
  561. { DOOR_DATA=40; DOOR_VALUE=len; strcpy(DOOR_MSG,mstring); DOORIO();
  562.  strcpy(mstring,DOOR_MSG); strcpy(DOOR_MSG,'\0'); strcpy(DOOR_MSG1,'\0'); }
  563.  
  564. //************************
  565. //*****  Write File  *****
  566. //************************
  567.  
  568. void WriteFile(char ostring[],char mstring[])
  569. { DOOR_DATA=16; strcpy(DOOR_MSG,ostring); strcpy(DOOR_MSG1,mstring); DOORIO();
  570.  strcpy(DOOR_MSG,'\0'); strcpy(DOOR_MSG1,'\0'); }
  571.